home *** CD-ROM | disk | FTP | other *** search
/ Light ROM 3 / Light ROM 3 - Disc 2.iso / programs / amiga / animfile / egsflick / egsfli.lha / EGSFlick / eflick.c next >
C/C++ Source or Header  |  1993-11-19  |  19KB  |  747 lines
  1.  
  2. /*
  3.             EGSFlick - Play .FLI/.FLC animations under EGS
  4.                 Frank Neumann, November 1993
  5.  
  6.             This program plays .FLI (fixed to 320x200) or .FLC (any
  7.             resolution) anim files in an EGS window on a graphic board
  8.             that is capable of producing an 8 bit, CLUT-based chunky pixel
  9.             display. This is true for most currently available Amiga graphic
  10.             boards, such as the Rainbow III, Piccolo, Spectrum and maybe
  11.             others that are still to come.
  12.  
  13.             History:
  14.             V1.0 24.03.1993  First version, already stable, but not to
  15.                              be released for a long time.
  16.  
  17.             V1.1 14.11.1993  Thought it would be a good idea to release this
  18.                              goodie - as EGS seems to become more and more
  19.                              used around the world. First release.
  20.             V1.1a 19.11.1993 Removed the Map->Type test of the EScreen - seems
  21.                              I have not yet understood some of EGS' concepts..
  22.  
  23.  
  24.             This code is mostly based on xflick for X11 systems. What follows is
  25.             the original comment:
  26.  
  27.                xflick - Ron Schnell, March, 1991
  28.  
  29.            This code is provided as is, with no warrantees, expressed
  30.                or implied.  I believe this code to be free of encumbrance,
  31.            and offer it to the public domain.  I ask, however, that
  32.            this paragraph and my name be retained in any modified
  33.            versions of the file you may make, and that you notify me
  34.            of any improvements you make to the code.
  35.  
  36.            Ron Schnell (ronnie@sos.com)
  37.  
  38.             The following changes are from Michael Pall
  39.             (pall@rz.uni-karlsruhe.de) Mar 25-28 1991:
  40.  
  41.             Lots of bugfixes and changes to the structure of the files.
  42.             The file is interpreted before we display it.
  43.             Moved the interpretation part to read.c.
  44.             We use Pixmaps and/or XImages.
  45.             Added interactive input to change the speed/single step.
  46.  
  47.             The following extensions are from Klaus Ehrenfried
  48.             (klaus@spock.es.go.dlr.de) Oct 23-24 1992:
  49.  
  50.             Add handling of FLI_DELTA and FLI_256_COLOR chunks.
  51.             Recognize magic number FLC_MAGIC = 0xaf12 for newer
  52.             flic files.
  53. */
  54.  
  55. #include <stdio.h>
  56. #include <string.h>
  57. #include <sys/types.h>
  58. #include <sys/signal.h>
  59. #include <sys/time.h>
  60. #include "eflick.h"
  61.  
  62. #include <exec/types.h>
  63. #include <clib/exec_protos.h>
  64. #include <egs/egsintui.h>
  65. #include <egs/clib/egsintui_protos.h>
  66. #include <egs/egsgfx.h>
  67. #include <egs/clib/egsgfx_protos.h>
  68. #include <egs/egs.h>
  69. #include <egs/clib/egs_protos.h>
  70.  
  71. /* Amiga version identification */
  72. static char *version[] = "$VER: EGSFlick 1.1a (19.11.93)";
  73.  
  74. int verbose = 0;
  75. static int jiffies;
  76.  
  77. /* pointers to required libraries */
  78. struct Library *EGSIntuiBase = NULL;
  79. struct Library *EGSBase = NULL;
  80. struct Library *EGSGfxBase = NULL;
  81. struct Library *EGSBlitBase = NULL;
  82.  
  83. static struct EI_NewWindow newWindow =
  84. {
  85.     50, 30, 10, 10, /* LeftEdge, TopEdge, Width, Height */
  86.     0, 0, 0, 0,        /* MinWidth,MinHeight, MaxWidth, MaxHeight */
  87.     NULL,            /* Screen */
  88.     EI_WINDOWCLOSE | EI_WINDOWBACK | EI_WINDOWDRAG,    /* SysGadgets */
  89.     NULL,            /* FirstGadgets */
  90.     "EGSFlick V1.1a by Franky",        /* Title */
  91.     EI_SMART_REFRESH | EI_GIMMEZEROZERO | EI_WINDOWACTIVE,    /* Flags */
  92.     EI_iCLOSEWINDOW | EI_iVANILLAKEY | EI_iACTIVEWINDOW | EI_iINACTIVEWINDOW,    /*EI_IDCMPFlags */
  93.     NULL,            /*Port */
  94.     {0,0,0,0,0,0,0},    /* Colors */
  95.     NULL,                /* Menu */
  96.     NULL                /* Render */
  97. };
  98.  
  99. EI_WindowPtr window = NULL;
  100. E_EBitMapPtr map;
  101. EG_RastPortPtr rp;
  102. E_CLU oldscreencolors[MAXCOL], screencolors[MAXCOL];
  103.  
  104. static flag_noint = 0;        /* Don't interpret file first */
  105.  
  106. static int fdelay;        /* Frame delay */
  107. static int wwidth, wheight;    /* Width and height of the window */
  108.  
  109. char fliname[256];
  110.  
  111. /* a modified XColor structure definition */
  112. typedef struct {
  113.     unsigned long pixel;
  114.     unsigned char red, green, blue;
  115. } XColor;
  116.  
  117.  
  118. /* The structure to hold the elements of the interpreted display list */
  119.  
  120. struct disp_list
  121. {
  122.     int disp_type;
  123.     int disp_frame;
  124.     E_EBitMapPtr disp_pix;
  125.     XColor *disp_cols;
  126.     int disp_numcol;
  127.     int disp_width, disp_height;
  128.     int disp_destx, disp_desty;
  129.     struct disp_list *disp_next;
  130. };
  131.  
  132. static struct disp_list disp_root;    /* The start of the display list */
  133. static struct disp_list *disp_cur;    /* The current position */
  134.  
  135. extern void interpret_fli();
  136.  
  137. /* prototypes */
  138. void Crash( char * );
  139.  
  140.  
  141. /* Convert the frame delay to microseconds/seconds */
  142. static void
  143. convert_fdelay()
  144. {
  145.     jiffies = (fdelay * 70) / 50;
  146.  
  147. }
  148.  
  149.  
  150. /* Print a usage message and exit */
  151. static void
  152. usage()
  153. {
  154.     (void) fprintf(stderr,
  155.     "Usage: EGSFlick [-v] [-r<count>] [-d<delay>] [-n] fli_file\n");
  156.     (void) fprintf(stderr, " -v Verbose Debugging info\n\
  157.  -r<count>  Repeat count times (0 = loop forever)\n\
  158.  -d<delay>  Delay between frames in 1/70s\n\
  159.  -n         Don't interpret file before display \
  160. (slower but uses less memory)\n");
  161.     exit(0);
  162. }
  163.  
  164.  
  165. /* Check for pending EI_iVANILLAKEY messages and process them */
  166. static void
  167. check_key()
  168. {
  169.     struct EI_EIntuiMsg *msg;
  170.  
  171.     static int stepflag = 0;    /* Default: singlestep is off */
  172.  
  173.     int onestep = stepflag;        /* 1 if we should be loop waiting for a step */
  174.  
  175.     while (NULL != (msg = (struct EI_EIntuiMsg *)GetMsg(window->UserPort)) || onestep)
  176.     {
  177.         if (msg != NULL)
  178.         {
  179.             switch (msg->Class)
  180.             {
  181.                 case EI_iVANILLAKEY:
  182.                     switch (msg->Code)
  183.                     {
  184.                         /* Minus: Slow down */
  185.                         case '-':
  186.                             fdelay++;
  187.                             convert_fdelay();
  188.                             break;
  189.  
  190.                         /* Plus: Speed up */
  191.                         case '+':
  192.                             if (fdelay)
  193.                                 fdelay--;
  194.                             convert_fdelay();
  195.                             break;
  196.  
  197.                         /* Space: Single step */
  198.                         case ' ':
  199.                             stepflag = 1;
  200.                             onestep = 0;
  201.                             break;
  202.  
  203.                         /* c: Continue animation */
  204.                         case 'c':
  205.                             stepflag = 0;
  206.                             onestep = 0;
  207.                             break;
  208.  
  209.                         /* 'q': Quit */
  210.                         case 'q':
  211.                             ReplyMsg(msg);
  212.                             Crash(NULL);
  213.                             break;
  214.                     }
  215.                     break;
  216.  
  217.                 case EI_iCLOSEWINDOW:
  218.                     ReplyMsg(msg);
  219.                     Crash(NULL);
  220.                     break;
  221.  
  222.                 case EI_iACTIVEWINDOW:
  223.                     E_SetRGB8CM(window->WScreen->EScreen, screencolors, 0, MAXCOL);
  224.                     break;
  225.  
  226.                 case EI_iINACTIVEWINDOW:
  227.                     E_SetRGB8CM(window->WScreen->EScreen, oldscreencolors, 0, MAXCOL);
  228.                     break;
  229.  
  230.                 default:
  231.                     printf("You don't really ever want to see this.\n");
  232.                     break;
  233.             }
  234.             ReplyMsg((struct Message *)msg);
  235.         }
  236.     }
  237. }
  238.  
  239.  
  240.  
  241. /* Function to display the interpretation immediately */
  242.  
  243. static void
  244. func_disp(ftype, frame, buf, srcx, srcy, destx, desty, swidth, sheight)
  245. int ftype;
  246. int frame;
  247. unsigned char *buf;
  248. int srcx, srcy;
  249. int destx, desty;
  250. int swidth, sheight;
  251. {
  252.     static int colchange=0;        /* Colormap has changed */
  253.  
  254.     switch (ftype)
  255.     {
  256.         case FLI_COPY:
  257.         case FLI_LC:
  258.         case FLI_DELTA:
  259.         case FLI_BRUN:
  260.             EG_CopyBitMapRastPort(map, rp, srcx, srcy, swidth, sheight, destx, desty);
  261.             break;
  262.  
  263.         case FLI_BLACK:
  264.               EG_SetAPen(rp, 0x00000000);
  265.             EG_RectFill(rp, destx, desty, swidth, sheight);
  266.             break;
  267.  
  268.         case FLI_COLOR:
  269.             while(srcy--)
  270.             {
  271.                 screencolors[srcx].Red   = ((*(buf++) & 0x3f) << 2);
  272.                 screencolors[srcx].Green = ((*(buf++) & 0x3f) << 2);
  273.                 screencolors[srcx].Blue  = ((*(buf++) & 0x3f) << 2);
  274.                 srcx++;
  275.             }
  276.             colchange = 1;
  277.             break;
  278.  
  279.         case FLI_256_COLOR:
  280.             while(srcy--)
  281.             {
  282.                 screencolors[srcx].Red   = ((*(buf++) & 0xff));
  283.                 screencolors[srcx].Green = ((*(buf++) & 0xff));
  284.                 screencolors[srcx].Blue  = ((*(buf++) & 0xff));
  285.                 srcx++;
  286.             }
  287.             colchange = 1;
  288.             break;
  289.  
  290.         case FLI_SYNC:
  291.             if (colchange)
  292.             {
  293.                 E_SetRGB8CM(window->WScreen->EScreen, screencolors, 0, MAXCOL);
  294.                 colchange = 0;
  295.             }
  296.  
  297.             check_key();
  298.  
  299.             /* Do we have a delay between the frames? */
  300.                if (jiffies)
  301.                    Delay(jiffies);
  302.  
  303.             break;
  304.     }
  305. }
  306.  
  307.  
  308.  
  309. /* Store the interpretation */
  310.  
  311. static void
  312. func_interp(ftype, frame, buf, srcx, srcy, destx, desty, swidth, sheight)
  313. int ftype;        /* The type of this chunk */
  314. int frame;        /* The number of this frame */
  315. unsigned char *buf;    /* A pointer to the pixel/colormap data */
  316. int srcx, srcy;        /* The upper left corner in the data array */
  317. int destx, desty;    /* The upper left corner in the window */
  318. int swidth, sheight;    /* The dimensions of the rectangle */
  319. {
  320.     XColor *coltmp;    /* Temporary storage for pointer to XColor struct */
  321.  
  322.     /* set title of EGS window to current frame number */
  323.     char framenum[20];
  324.     sprintf(framenum, "load: frame %d", disp_cur->disp_frame);
  325.     EI_SetWindowTitles(window, framenum, (char *)-1);
  326.  
  327.     /* Allocate another element in the display list */
  328.     disp_cur->disp_next = (struct disp_list *)malloc(sizeof(struct disp_list));
  329.     disp_cur = disp_cur->disp_next;
  330.  
  331.     /* Clear the pointer to the next element so we find the end of the list */
  332.     disp_cur->disp_next = (struct disp_list *)0;
  333.  
  334.     /* Copy info pertaining to all or most of the chunks */
  335.     disp_cur->disp_type = ftype;
  336.     disp_cur->disp_frame = frame;
  337.     disp_cur->disp_width = swidth;
  338.     disp_cur->disp_height = sheight;
  339.     disp_cur->disp_destx = destx;
  340.     disp_cur->disp_desty = desty;
  341.     disp_cur->disp_pix = (E_EBitMapPtr)NULL;
  342.  
  343.     switch (ftype)
  344.     {
  345.         case FLI_COPY:
  346.         case FLI_LC:
  347.         case FLI_DELTA:
  348.         case FLI_BRUN:
  349.             disp_cur->disp_pix = E_AllocBitMap(wwidth, wheight, 8, E_PIXELMAP, 0, 0);
  350.             if (disp_cur->disp_pix == NULL)
  351.                 Crash("could not allocate memory for picture");
  352.             disp_cur->disp_pix->Lock++;
  353.  
  354.             EB_CopyBitMap(map, disp_cur->disp_pix, srcx, srcy, swidth, sheight, 0, 0, 0);
  355.             break;
  356.  
  357.         case FLI_COLOR:
  358.             /* Create an array of XColor to hold the colors. Specific to FLI_COLOR:
  359.                srcx is the starting color index and srcy is the number of colors */
  360.  
  361.             coltmp = (XColor *)malloc(srcy * sizeof(XColor));
  362.             disp_cur->disp_cols = coltmp;
  363.             disp_cur->disp_numcol = srcy;
  364.  
  365.             /* Copy the changed colors to the XColor array */
  366.             while(srcy--)
  367.             {
  368.                 coltmp->red = ((*(buf++) & 0x3f) << 2);
  369.                 coltmp->green = ((*(buf++) & 0x3f) << 2);
  370.                 coltmp->blue = ((*(buf++) & 0x3f) << 2);
  371.                 coltmp->pixel = srcx++;
  372.                 coltmp++;
  373.             }
  374.             break;
  375.  
  376.         case FLI_256_COLOR:
  377.             /* Create an array of XColor to hold the colors. Specific to FLI_256_COLOR:
  378.                srcx is the starting color index and srcy is the number of colors */
  379.             coltmp =  (XColor *)malloc(srcy * sizeof(XColor));
  380.             disp_cur->disp_cols = coltmp;
  381.             disp_cur->disp_numcol = srcy;
  382.  
  383.             /* Copy the changed colors to the XColor array */
  384.             while(srcy--)
  385.             {
  386.                 coltmp->red = ((*(buf++) & 0xff));
  387.                 coltmp->green = ((*(buf++) & 0xff));
  388.                 coltmp->blue = ((*(buf++) & 0xff));
  389.                 coltmp->pixel = srcx++;
  390.                 coltmp++;
  391.             }
  392.             break;
  393.  
  394.         /* FLI_BLACK and FLI_SYNC only need to be stored */
  395.         case FLI_BLACK:
  396.         case FLI_SYNC:
  397.             break;
  398.     }
  399.  
  400. }
  401.  
  402.  
  403. /* Display the stored interpretation */
  404.  
  405. static void
  406. display_interp(dc)
  407. struct disp_list *dc;    /* The structure holding the info on the chunk */
  408. {
  409.     static int colchange=0;    /* Colormap has changed */
  410.     int idx, pixel, numcols;
  411.     int swidth, sheight;    /* Dimension of the changing rectangle */
  412.     int destx, desty;        /* Upper left corner of the rectangle */
  413.  
  414.     /* Copy some fields from the structure */
  415.     swidth = dc->disp_width;
  416.     sheight = dc->disp_height;
  417.     destx = dc->disp_destx;
  418.     desty = dc->disp_desty;
  419.  
  420.     switch (dc->disp_type)
  421.     {
  422.         case FLI_COPY:
  423.         case FLI_LC:
  424.         case FLI_DELTA:
  425.         case FLI_BRUN:
  426.             EG_CopyBitMapRastPort(dc->disp_pix, rp, 0, 0, swidth, sheight, destx, desty);
  427.             break;
  428.  
  429.         case FLI_BLACK:
  430.             /* Clear the whole rectangle */
  431.             EG_SetAPen(rp, 0x00000000);
  432.             EG_RectFill(rp, destx, desty, swidth, sheight);
  433.             break;
  434.  
  435.         case FLI_COLOR:
  436.         case FLI_256_COLOR:
  437.             /* Store the changed colors in the colormap and note that */
  438.             idx = 0;
  439.             numcols = dc->disp_numcol;
  440.             while(numcols--)
  441.             {
  442.                 pixel = dc->disp_cols[idx].pixel;
  443.                 screencolors[pixel].Red   = dc->disp_cols[idx].red;
  444.                 screencolors[pixel].Green = dc->disp_cols[idx].green;
  445.                 screencolors[pixel].Blue  = dc->disp_cols[idx].blue;
  446.                 idx++;
  447.             }
  448.             colchange = 1;
  449.             break;
  450.  
  451.         case FLI_SYNC:
  452.             /* If the colors have changed we set the colormap for the window */
  453.             if (colchange)
  454.             {
  455.                 E_SetRGB8CM(window->WScreen->EScreen, screencolors, 0, MAXCOL);
  456.                 colchange = 0;
  457.             }
  458.  
  459.             check_key();
  460.  
  461.                if (jiffies)
  462.                    Delay(jiffies);
  463.  
  464.             break;
  465.     }
  466. }
  467.  
  468.  
  469. /* Draw a given string to the center of the window */
  470.  
  471. static void
  472. text_center(str)
  473. char *str;
  474. {
  475.     int w;
  476.  
  477.     EG_SetAPen(rp, 0x00000000);
  478.     EG_RectFill(rp, 0, 0, wwidth, wheight);
  479.  
  480.     /* Determine the width of the string */
  481.     w = EG_TextLength(rp, str, strlen(str));
  482.     if (w > wwidth)
  483.         w = wwidth;
  484.  
  485.     /* And draw the string */
  486.     EG_SetAPen(rp, 0xffffff00);
  487.     EG_Move(rp, (wwidth-w)/2, wheight/2);
  488.     EG_Text(rp, str, strlen(str));
  489. }
  490.  
  491.  
  492. main(argc, argv)
  493. int argc;
  494. char *argv[];
  495. {
  496.     int fd;            /* For the main file descriptor */
  497.     struct fli_header header;    /* To hold the main header */
  498.     unsigned char *data;    /* Always has the current image data */
  499.     int repeatcount;        /* How many times to loop */
  500.     unsigned char notfirst;    /* Is this not the first time through? */
  501.     char *fname;        /* Pointer to filename */
  502.     int depth;          /* depth of (EGS default) screen */
  503.  
  504.     fdelay = -1;
  505.     repeatcount = 10;
  506.  
  507.     /* required very early for (possible) error handling */
  508.     disp_root.disp_next = (struct disp_list *)0;
  509.  
  510.     while (--argc && argv[1][0] == '-')
  511.     {
  512.         argv++;
  513.         switch (argv[0][1])
  514.         {
  515.             case 'r':
  516.                 repeatcount = atol(&(argv[0][2]));
  517.                 break;
  518.             case 'd':
  519.                 fdelay = atol(&(argv[0][2]));
  520.                 break;
  521.             case 'n':
  522.                 flag_noint = 1;
  523.                 break;
  524.             case 'v':
  525.                 verbose = 1;
  526.                 break;
  527.             default:
  528.                 usage();
  529.         }
  530.  
  531.     }
  532.  
  533.     if (argc != 1)
  534.         usage();
  535.  
  536.     fname = argv[1];
  537.     strcpy(fliname, argv[1]);
  538.  
  539.     fd = open(fname, 0);
  540.     if (fd < 0)
  541.     {
  542.         (void) fprintf(stderr, "Error opening %s.\n", fname);
  543.         perror("EGSFlick");
  544.         exit(1);
  545.     }
  546.  
  547.     /* Read the main FLI header */
  548.     read_flihead(fd, &header);
  549.  
  550.     if (((header.fhd_magic & 0x0000ffff) != FLI_MAGIC) &&
  551.         ((header.fhd_magic & 0x0000ffff) != FLC_MAGIC))
  552.     {
  553.         (void) fprintf(stderr, "%s, not a .fli file.\n", fname);
  554.         exit(0);
  555.     }
  556.  
  557.     /* Get the width and height */
  558.  
  559.     wwidth = header.fhd_width;
  560.     wheight = header.fhd_height;
  561.  
  562.     /* The speed is stored in 1/70 seconds, convert to usecs */
  563.     if (fdelay < 0)
  564.         fdelay = header.fhd_speed;
  565.  
  566.     convert_fdelay();
  567.  
  568.     /* open the required EGS libraries */
  569.     EGSBase = OpenLibrary("egs.library", 0);
  570.     if (NULL == EGSBase)
  571.         Crash ("couldn't open 'egs.library' -- stop.");
  572.  
  573.     EGSBlitBase = OpenLibrary("egsblit.library", 0);
  574.     if (NULL == EGSBlitBase)
  575.         Crash ("couldn't open 'egsblit.library' -- stop.");
  576.  
  577.     EGSIntuiBase = OpenLibrary("egsintui.library", 0);
  578.     if (NULL == EGSIntuiBase)
  579.         Crash ("couldn't open 'egsintui.library' -- stop.");
  580.  
  581.     EGSGfxBase = OpenLibrary("egsgfx.library", 0);
  582.     if (NULL == EGSGfxBase)
  583.         Crash ("couldn't open 'egsgfx.library' -- stop.");
  584.  
  585.  
  586.     /*
  587.         open EGS window on the default screen, hoping that it's currently set
  588.         to 8 bit
  589.     */
  590.  
  591.     /* Create a wwidth x wheight window to show the flick */
  592.     newWindow.Width = wwidth;
  593.     newWindow.Height = wheight;
  594.     window = EI_OpenWindow(&newWindow);
  595.     if (window == NULL)
  596.         Crash("Couldn't open EGS window -- stop.");
  597.  
  598.     /* save current color table */
  599.     E_GetRGB8CM(window->WScreen->EScreen, oldscreencolors, 0, MAXCOL);
  600.     E_GetRGB8CM(window->WScreen->EScreen, screencolors, 0, MAXCOL);
  601.  
  602.     /* check if the EGS default screen is really an 8 bit screen - if not, exit */
  603.     depth = window->WScreen->EScreen->Map->Depth;
  604.  
  605. #if 0
  606.     /* This is the 'old' test - doesn't work on a Spectrum, however, so I removed it for now.. */
  607.     if ((window->WScreen->EScreen->Map->Depth != 8) ||
  608.         (window->WScreen->EScreen->Map->Type != E_PIXELMAP))
  609. #endif
  610.  
  611.     if (window->WScreen->EScreen->Map->Depth != 8)
  612.         Crash("Screen has a wrong depth - we need an 8 bit chunky pixel screen.");
  613.  
  614.     /* for faster access to this structure...*/
  615.     rp = window->RPort;
  616.  
  617.     /* now allocate memory for the image via EGS */
  618.     map = E_AllocBitMap(wwidth, wheight, 8, E_PIXELMAP, 0, 0);
  619.     if (map == NULL)
  620.         Crash("could not allocate memory for off-screen bitmap");
  621.  
  622.     /* increase lock counter on map so it doesn't get mapped away */
  623.     map->Lock++;
  624.  
  625.     /* old version...      data = map->Typekey.PixelMap.Planes.Dest; */
  626.     data = map->Plane;
  627.  
  628.     notfirst = 0;
  629.  
  630.     /* Either interpret the file while displaying it */
  631.  
  632.     if (flag_noint)
  633.     {
  634.         EI_SetWindowTitles(window, fliname, (char *)-1);
  635.         if (repeatcount)
  636.         {
  637.             while (repeatcount--)
  638.             {
  639.                 interpret_fli(fd, &header, data, notfirst, func_disp);
  640.                 notfirst = 1;
  641.             }
  642.         }
  643.         else
  644.         {
  645.             for(;;)
  646.             {
  647.                 interpret_fli(fd, &header, data, notfirst, func_disp);
  648.                 notfirst = 1;
  649.             }
  650.         }
  651.     }
  652.  
  653.     /* Or interpret everything first and display it afterwards */
  654.     else
  655.     {
  656.         text_center("Please wait while loading the animation");
  657.  
  658.         /* Interpret it and store the results */
  659.         disp_cur = &disp_root;
  660.         interpret_fli(fd, &header, data, 0, func_interp);
  661.  
  662.         /* Now display the results */
  663.         EI_SetWindowTitles(window, fliname, (char *)-1);
  664.  
  665.         if (repeatcount)
  666.         {
  667.             while (repeatcount--)
  668.             {
  669.                 disp_cur = &disp_root;
  670.                 while (disp_cur->disp_next)
  671.                 {
  672.                     disp_cur = disp_cur->disp_next;
  673.  
  674.                     /* Only display the first frame once */
  675.                     if (disp_cur->disp_frame || !notfirst)
  676.                         display_interp(disp_cur);
  677.                 }
  678.                 notfirst = 1;
  679.             }
  680.         }
  681.         else
  682.         {
  683.             for (;;)
  684.             {
  685.                 disp_cur = &disp_root;
  686.                 while (disp_cur->disp_next)
  687.                 {
  688.                     disp_cur = disp_cur->disp_next;
  689.  
  690.                     /* Only display the first frame once */
  691.                     if (disp_cur->disp_frame || !notfirst)
  692.                         display_interp(disp_cur);
  693.                 }
  694.                 notfirst = 1;
  695.             }
  696.         }
  697.     }
  698.  
  699.     Crash(NULL);
  700. }
  701.  
  702.  
  703. void Crash (char *string)
  704. {
  705.     /* free bitmaps in display list */
  706.     disp_cur = &disp_root;
  707.     while (disp_cur->disp_next)
  708.     {
  709.         disp_cur = disp_cur->disp_next;
  710.         if (disp_cur->disp_pix)
  711.         {
  712.             disp_cur->disp_pix->Lock--;
  713.             E_DisposeBitMap(disp_cur->disp_pix);
  714.         }
  715.     }
  716.  
  717.     if (window)
  718.     {
  719.         /* restore original color map (only if window was opened before) */
  720.         E_SetRGB8CM(window->WScreen->EScreen, oldscreencolors, 0, MAXCOL);
  721.     }
  722.  
  723.     if (map)
  724.     {
  725.         map->Lock--;
  726.         E_DisposeBitMap(map);
  727.     }
  728.     if (window)
  729.         EI_CloseWindow(window);
  730.     if (EGSBase)
  731.         CloseLibrary(EGSBase);
  732.     if (EGSBlitBase)
  733.         CloseLibrary(EGSBlitBase);
  734.     if (EGSIntuiBase)
  735.         CloseLibrary(EGSIntuiBase);
  736.     if (EGSGfxBase)
  737.         CloseLibrary(EGSGfxBase);
  738.     if (NULL == string)
  739.         exit (0);
  740.     else
  741.     {
  742.         printf ("%s.\n", string);
  743.         exit (10);
  744.     }
  745. }
  746.  
  747.